package com.hexingmo.dawn.lang;

import javax.sound.sampled.AudioSystem;
import java.awt.*;
import java.awt.print.PrinterJob;
import java.io.File;
import java.lang.management.ManagementFactory;
import java.util.Properties;

/**
 * 系统工具类，提供操作系统判断功能
 * 
 * @author He Xing Mo
 * @since 1.0
 */
public class SystemUtils {

    private static OsProperty osProperty;

    private SystemUtils() {
        throw new IllegalStateException("Static utility classes do not support instantiation");
    }

    public static synchronized OsProperty getOsProperty() {
        if (osProperty != null) {
            return osProperty;
        }
        String name = get(JavaPropsKey.OS_NAME , "");
        String version = get(JavaPropsKey.OS_VERSION , "");
        String arch = get(JavaPropsKey.OS_ARCH , "");
        SystemUtils.osProperty = new OsProperty(name , version , arch);
        return SystemUtils.osProperty;
    }

    // ==================== Windows 系列 ====================
    
    /**
     * 判断是否为 Windows 操作系统
     */
    public static boolean isWindows() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("windows");
    }
    
    /**
     * 判断是否为 Windows 10
     */
    public static boolean isWindows10() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("10");
    }
    
    /**
     * 判断是否为 Windows 11
     */
    public static boolean isWindows11() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("11");
    }
    
    /**
     * 判断是否为 Windows 8
     */
    public static boolean isWindows8() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("6.2");
    }
    
    /**
     * 判断是否为 Windows 7
     */
    public static boolean isWindows7() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("6.1");
    }
    
    /**
     * 判断是否为 Windows Vista
     */
    public static boolean isWindowsVista() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("6.0");
    }
    
    /**
     * 判断是否为 Windows XP
     */
    public static boolean isWindowsXP() {
        String osName = getOsProperty().getName().toLowerCase();
        String osVersion = getOsProperty().getVersion();
        return osName.contains("windows") && osVersion.startsWith("5.1");
    }
    
    /**
     * 判断是否为 Windows Server
     */
    public static boolean isWindowsServer() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("windows") && osName.contains("server");
    }

    // ==================== Linux 系列 ====================
    
    /**
     * 判断是否为 Linux 操作系统
     */
    public static boolean isLinux() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("linux");
    }
    
    /**
     * 判断是否为 Ubuntu
     */
    public static boolean isUbuntu() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("ubuntu");
    }
    
    /**
     * 判断是否为 CentOS
     */
    public static boolean isCentOS() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("centos");
    }
    
    /**
     * 判断是否为 Red Hat
     */
    public static boolean isRedHat() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("red hat") || osName.contains("redhat");
    }
    
    /**
     * 判断是否为 Debian
     */
    public static boolean isDebian() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("debian");
    }
    
    /**
     * 判断是否为 Fedora
     */
    public static boolean isFedora() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("fedora");
    }
    
    /**
     * 判断是否为 SUSE
     */
    public static boolean isSUSE() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("suse") || osName.contains("opensuse");
    }
    
    /**
     * 判断是否为 Alpine Linux
     */
    public static boolean isAlpine() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("alpine");
    }
    
    /**
     * 判断是否为 Amazon Linux
     */
    public static boolean isAmazonLinux() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("amazon");
    }

    // ==================== macOS 系列 ====================
    
    /**
     * 判断是否为 macOS 操作系统
     */
    public static boolean isMacOS() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("mac") || osName.contains("darwin");
    }
    
    /**
     * 判断是否为 macOS 13 (Ventura)
     */
    public static boolean isMacOSVentura() {
        if (!isMacOS()) {
            return false;
        }
        String osVersion = getOsProperty().getVersion();
        return osVersion.startsWith("22.");
    }
    
    /**
     * 判断是否为 macOS 12 (Monterey)
     */
    public static boolean isMacOSMonterey() {
        if (!isMacOS()) {
            return false;
        }
        String osVersion = getOsProperty().getVersion();
        return osVersion.startsWith("21.");
    }
    
    /**
     * 判断是否为 macOS 11 (Big Sur)
     */
    public static boolean isMacOSBigSur() {
        if (!isMacOS()) {
            return false;
        }
        String osVersion = getOsProperty().getVersion();
        return osVersion.startsWith("20.");
    }
    
    /**
     * 判断是否为 macOS 10.15 (Catalina)
     */
    public static boolean isMacOSCatalina() {
        if (!isMacOS()) {
            return false;
        }
        String osVersion = getOsProperty().getVersion();
        return osVersion.startsWith("19.");
    }

    // ==================== Unix 系列 ====================
    
    /**
     * 判断是否为 Unix 操作系统
     */
    public static boolean isUnix() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("unix") || osName.contains("aix") || 
               osName.contains("hp-ux") || osName.contains("solaris");
    }
    
    /**
     * 判断是否为 AIX
     */
    public static boolean isAIX() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("aix");
    }
    
    /**
     * 判断是否为 HP-UX
     */
    public static boolean isHPUX() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("hp-ux");
    }
    
    /**
     * 判断是否为 Solaris
     */
    public static boolean isSolaris() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("solaris") || osName.contains("sunos");
    }

    // ==================== 移动操作系统 ====================
    
    /**
     * 判断是否为 Android
     */
    public static boolean isAndroid() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("android");
    }
    
    /**
     * 判断是否为 iOS
     */
    public static boolean isIOS() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("ios");
    }

    // ==================== 其他操作系统 ====================
    
    /**
     * 判断是否为 FreeBSD
     */
    public static boolean isFreeBSD() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("freebsd");
    }
    
    /**
     * 判断是否为 NetBSD
     */
    public static boolean isNetBSD() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("netbsd");
    }
    
    /**
     * 判断是否为 OpenBSD
     */
    public static boolean isOpenBSD() {
        String osName = getOsProperty().getName().toLowerCase();
        return osName.contains("openbsd");
    }

    // ==================== 架构判断 ====================
    
    /**
     * 判断是否为 x86 架构
     */
    public static boolean isX86() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("x86") || arch.contains("i386") || arch.contains("i686");
    }
    
    /**
     * 判断是否为 x64 架构
     */
    public static boolean isX64() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("x64") || arch.contains("amd64") || arch.contains("x86_64");
    }
    
    /**
     * 判断是否为 ARM 架构
     */
    public static boolean isARM() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("arm");
    }
    
    /**
     * 判断是否为 ARM64 架构
     */
    public static boolean isARM64() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("aarch64") || arch.contains("arm64");
    }
    
    /**
     * 判断是否为 MIPS 架构
     */
    public static boolean isMIPS() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("mips");
    }
    
    /**
     * 判断是否为 PowerPC 架构
     */
    public static boolean isPowerPC() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("ppc") || arch.contains("powerpc");
    }

    // ==================== 通用判断方法 ====================
    
    /**
     * 判断是否为桌面操作系统
     */
    public static boolean isDesktop() {
        return isWindows() || isMacOS() || isLinux();
    }
    
    /**
     * 判断是否为服务器操作系统
     */
    public static boolean isServer() {
        return isWindowsServer() || isLinux() || isUnix();
    }
    
    /**
     * 判断是否为移动操作系统
     */
    public static boolean isMobile() {
        return isAndroid() || isIOS();
    }
    
    /**
     * 判断是否为 64 位系统
     */
    public static boolean is64Bit() {
        String arch = getOsProperty().getArch().toLowerCase();
        return arch.contains("64") || arch.contains("x86_64") || arch.contains("amd64") || 
               arch.contains("aarch64") || arch.contains("arm64");
    }
    
    /**
     * 判断是否为 32 位系统
     */
    public static boolean is32Bit() {
        return !is64Bit();
    }

    // ==================== 系统能力检测 ====================

    /**
     * 检测系统是否支持 GUI
     */
    public static boolean isGuiSupported() {
        try {
            return !GraphicsEnvironment.isHeadless();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检测是否为无头环境（服务器环境）
     */
    public static boolean isHeadless() {
        try {
            return GraphicsEnvironment.isHeadless();
        } catch (Exception e) {
            return true;
        }
    }

    /**
     * 检测系统是否支持声音
     */
    public static boolean isSoundSupported() {
        try {
            return AudioSystem.getMixerInfo().length > 0;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检测系统是否支持打印
     */
    public static boolean isPrintingSupported() {
        try {
            return PrinterJob.lookupPrintServices().length > 0;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检测是否为容器环境（Docker等）
     */
    public static boolean isContainerEnvironment() {
        try {
            // 检查常见的容器标识文件
            File cgroup = new File("/proc/1/cgroup");
            if (cgroup.exists()) {
                String content = readFileContent(cgroup);
                return content.contains("docker") || content.contains("kubepods") ||
                        content.contains("containerd") || content.contains("lxc");
            }

            // 检查环境变量
            String containerEnv = System.getenv("container");
            if (containerEnv != null && !containerEnv.isEmpty()) {
                return true;
            }

            // 检查Docker相关环境变量
            return System.getenv("DOCKER_CONTAINER") != null ||
                    System.getenv("KUBERNETES_SERVICE_HOST") != null;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检测是否为云环境
     */
    public static boolean isCloudEnvironment() {
        try {
            // 检查云服务商的特征文件或环境变量
            String[] cloudIndicators = {
                    "/sys/hypervisor/uuid",  // AWS
                    "/sys/devices/virtual/dmi/id/product_name",  // 云实例标识
                    "/proc/1/environ"  // 环境变量
            };

            for (String indicator : cloudIndicators) {
                File file = new File(indicator);
                if (file.exists()) {
                    String content = readFileContent(file);
                    if (content.contains("amazon") || content.contains("aws") ||
                            content.contains("google") || content.contains("gcp") ||
                            content.contains("microsoft") || content.contains("azure") ||
                            content.contains("alibaba") || content.contains("aliyun")) {
                        return true;
                    }
                }
            }

            // 检查环境变量
            String[] cloudEnvVars = {
                    "AWS_EXECUTION_ENV", "GCP_PROJECT", "AZURE_CLOUD_ENVIRONMENT",
                    "ALIBABA_CLOUD_ENVIRONMENT", "TENCENT_CLOUD_ENVIRONMENT"
            };

            for (String envVar : cloudEnvVars) {
                if (System.getenv(envVar) != null) {
                    return true;
                }
            }

            return false;
        } catch (Exception e) {
            return false;
        }
    }

    // ==================== 系统工具函数 ====================

    /**
     * 执行系统命令
     */
    public static Process executeCommand(String command) throws Exception {
        if (isWindows()) {
            return Runtime.getRuntime().exec("cmd /c " + command);
        } else {
            return Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", command});
        }
    }

    /**
     * 执行系统命令并获取输出
     */
    public static String executeCommandAndGetOutput(String command) throws Exception {
        Process process = executeCommand(command);
        try (java.io.BufferedReader reader = new java.io.BufferedReader(
                new java.io.InputStreamReader(process.getInputStream()))) {
            StringBuilder output = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                output.append(line).append("\n");
            }
            process.waitFor();
            return output.toString().trim();
        }
    }

    /**
     * 获取系统启动时间（毫秒）
     */
    public static long getSystemUptime() {
        try {
            return ManagementFactory.getRuntimeMXBean().getUptime();
        } catch (Exception e) {
            return -1;
        }
    }

    /**
     * 获取进程ID
     */
    public static long getProcessId() {
        try {
            String processName = ManagementFactory.getRuntimeMXBean().getName();
            return Long.parseLong(processName.split("@")[0]);
        } catch (Exception e) {
            return -1;
        }
    }
    

    /**
     * 读取文件内容
     */
    private static String readFileContent(File file) {
        try {
            StringBuilder content = new StringBuilder();
            try (java.io.BufferedReader reader = new java.io.BufferedReader(
                    new java.io.FileReader(file))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    content.append(line).append("\n");
                }
            }
            return content.toString();
        } catch (Exception e) {
            return "";
        }
    }

    // ==================== 系统属性工具方法 ====================

    /**
     * 安全获取系统属性，如果发生SecurityException则返回null
     *
     * @param key 系统属性键
     * @return 系统属性值，如果不存在或发生SecurityException则返回null
     */
    public static String get(String key) {
        try {
            return System.getProperty(key);
        } catch (SecurityException e) {
            return null;
        }
    }

    /**
     * 安全获取系统属性，如果发生SecurityException则返回默认值
     *
     * @param key 系统属性键
     * @param defaultValue 默认值
     * @return 系统属性值，如果不存在或发生SecurityException则返回默认值
     */
    public static String get(String key, String defaultValue) {
        try {
            return System.getProperty(key, defaultValue);
        } catch (SecurityException e) {
            return defaultValue;
        }
    }

    /**
     * 安全获取系统属性并转换为整数，如果发生SecurityException或转换失败则返回默认值
     *
     * @param key 系统属性键
     * @param defaultValue 默认值
     * @return 系统属性值转换后的整数，如果失败则返回默认值
     */
    public static int getInt(String key, int defaultValue) {
        try {
            String value = System.getProperty(key);
            if (value != null) {
                return Integer.parseInt(value);
            }
            return defaultValue;
        } catch (SecurityException | NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 安全获取系统属性并转换为长整数，如果发生SecurityException或转换失败则返回默认值
     *
     * @param key 系统属性键
     * @param defaultValue 默认值
     * @return 系统属性值转换后的长整数，如果失败则返回默认值
     */
    public static long getLong(String key, long defaultValue) {
        try {
            String value = System.getProperty(key);
            if (value != null) {
                return Long.parseLong(value);
            }
            return defaultValue;
        } catch (SecurityException | NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 安全获取系统属性并转换为双精度浮点数，如果发生SecurityException或转换失败则返回默认值
     *
     * @param key 系统属性键
     * @param defaultValue 默认值
     * @return 系统属性值转换后的双精度浮点数，如果失败则返回默认值
     */
    public static double getDouble(String key, double defaultValue) {
        try {
            String value = System.getProperty(key);
            if (value != null) {
                return Double.parseDouble(value);
            }
            return defaultValue;
        } catch (SecurityException | NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 安全获取系统属性并转换为布尔值，如果发生SecurityException则返回默认值
     *
     * @param key 系统属性键
     * @param defaultValue 默认值
     * @return 系统属性值转换后的布尔值，如果失败则返回默认值
     */
    public static boolean getBoolean(String key, boolean defaultValue) {
        try {
            String value = System.getProperty(key);
            if (value != null) {
                return Boolean.parseBoolean(value);
            }
            return defaultValue;
        } catch (SecurityException e) {
            return defaultValue;
        }
    }

    /**
     * 安全设置系统属性，如果发生SecurityException则返回false
     *
     * @param key 系统属性键
     * @param value 系统属性值
     * @return 设置是否成功
     */
    public static boolean setProperty(String key, String value) {
        try {
            System.setProperty(key, value);
            return true;
        } catch (SecurityException e) {
            return false;
        }
    }

    /**
     * 安全清除系统属性，如果发生SecurityException则返回false
     *
     * @param key 系统属性键
     * @return 清除是否成功
     */
    public static boolean clearProperty(String key) {
        try {
            System.clearProperty(key);
            return true;
        } catch (SecurityException e) {
            return false;
        }
    }

    /**
     * 安全获取所有系统属性，如果发生SecurityException则返回空Properties对象
     *
     * @return 系统属性集合，如果发生SecurityException则返回空集合
     */
    public static Properties getProperties() {
        try {
            return System.getProperties();
        } catch (SecurityException e) {
            return new Properties();
        }
    }

    /**
     * 检查系统属性是否存在且不为空
     *
     * @param key 系统属性键
     * @return 如果属性存在且不为空返回true，否则返回false
     */
    public static boolean hasProperty(String key) {
        try {
            String value = System.getProperty(key);
            return value != null && !value.trim().isEmpty();
        } catch (SecurityException e) {
            return false;
        }
    }

    

    /**
     * 获取系统时间戳
     */
    public static long getSystemTime() {
        return System.currentTimeMillis();
    }

    /**
     * 获取系统纳秒时间
     */
    public static long getSystemNanoTime() {
        return System.nanoTime();
    }

    public static String getEnv(String name) {
        try {
            return System.getenv(name);
        } catch (SecurityException e) {
            return null;
        }
    }

    /**
     * 安全获取环境变量，如果发生SecurityException则返回默认值
     */
    public static String getEnv(String name, String defaultValue) {
        try {
            String value = System.getenv(name);
            return value != null ? value : defaultValue;
        } catch (SecurityException e) {
            return defaultValue;
        }
    }

    /**
     * 检查环境变量是否存在且不为空
     */
    public static boolean hasEnv(String name) {
        try {
            String value = System.getenv(name);
            return value != null && !value.trim().isEmpty();
        } catch (SecurityException e) {
            return false;
        }
    }

    /**
     * 获取PATH环境变量
     */
    public static String getPath() {
        return getEnv("PATH", "");
    }

    /**
     * 获取JAVA_HOME环境变量
     */
    public static String getJavaHomeEnv() {
        return getEnv("JAVA_HOME", "");
    }

    /**
     * 获取TEMP环境变量
     */
    public static String getTemp() {
        return getEnv("TEMP", getEnv("TMP", ""));
    }

    // ==================== CPU和架构相关属性获取方法 ====================
    
    /**
     * 获取CPU架构列表
     * @return CPU架构列表，如果获取失败返回null
     */
    public static String getCpuIsalist() {
        return get(JavaPropsKey.SUN_CPU_ISALIST);
    }
    
    /**
     * 获取CPU字节序
     * @return CPU字节序（"little"或"big"），如果获取失败返回null
     */
    public static String getCpuEndian() {
        return get(JavaPropsKey.SUN_CPU_ENDIAN);
    }
    
    /**
     * 获取数据模型架构
     * @return 数据模型（"32"或"64"），如果获取失败返回null
     */
    public static String getArchDataModel() {
        return get(JavaPropsKey.SUN_ARCH_DATA_MODEL);
    }
    
    /**
     * 判断是否为64位系统
     * @return 如果是64位系统返回true，否则返回false
     */
    public static boolean is64BitArchitecture() {
        String dataModel = getArchDataModel();
        return "64".equals(dataModel);
    }

    // ==================== 桌面环境相关属性获取方法 ====================
    
    /**
     * 获取桌面环境信息
     * @return 桌面环境信息，如果获取失败返回null
     */
    public static String getDesktop() {
        return get(JavaPropsKey.SUN_DESKTOP);
    }

    // ==================== 编码相关属性获取方法 ====================
    
    /**
     * 获取Unicode编码方式
     * @return Unicode编码方式，如果获取失败返回null
     */
    public static String getUnicodeEncoding() {
        return get(JavaPropsKey.SUN_IO_UNICODE_ENCODING);
    }
    
    /**
     * 获取文件编码
     * @return 系统默认文件编码，如果获取失败返回null
     */
    public static String getFileEncoding() {
        return get(JavaPropsKey.FILE_ENCODING);
    }
    
    /**
     * 获取JNU编码
     * @return JNU编码，如果获取失败返回null
     */
    public static String getJnuEncoding() {
        return get(JavaPropsKey.SUN_JNU_ENCODING);
    }
    
    /**
     * 获取文件编码包
     * @return 文件编码包信息，如果获取失败返回null
     */
    public static String getFileEncodingPkg() {
        return get(JavaPropsKey.FILE_ENCODING_PKG);
    }

    // ==================== Java供应商相关属性获取方法 ====================
    
    /**
     * 获取Java供应商
     * @return Java供应商信息，如果获取失败返回null
     */
    public static String getJavaVendor() {
        return get(JavaPropsKey.JAVA_VENDOR);
    }
    
    /**
     * 获取Java供应商URL
     * @return Java供应商官方网站URL，如果获取失败返回null
     */
    public static String getJavaVendorUrl() {
        return get(JavaPropsKey.JAVA_VENDOR_URL);
    }
    
    /**
     * 获取Java供应商Bug报告URL
     * @return Java供应商Bug报告页面URL，如果获取失败返回null
     */
    public static String getJavaVendorUrlBug() {
        return get(JavaPropsKey.JAVA_VENDOR_URL_BUG);
    }

    // ==================== 文件系统相关属性获取方法 ====================
    
    /**
     * 获取文件分隔符
     * @return 系统文件路径分隔符，如果获取失败返回null
     */
    public static String getFileSeparator() {
        return get(JavaPropsKey.FILE_SEPARATOR);
    }
    
    /**
     * 获取路径分隔符
     * @return 系统路径分隔符，如果获取失败返回null
     */
    public static String getPathSeparator() {
        return get(JavaPropsKey.PATH_SEPARATOR);
    }
    
    /**
     * 获取行分隔符
     * @return 系统行分隔符，如果获取失败返回null
     */
    public static String getLineSeparator() {
        return get(JavaPropsKey.LINE_SEPARATOR);
    }

    // ==================== Java版本相关属性获取方法 ====================
    
    /**
     * 获取Java版本
     * @return Java运行时版本号，如果获取失败返回null
     */
    public static String getJavaVersion() {
        return get(JavaPropsKey.JAVA_VERSION);
    }
    
    /**
     * 获取Java运行时版本
     * @return Java运行时完整版本信息，如果获取失败返回null
     */
    public static String getJavaRuntimeVersion() {
        return get(JavaPropsKey.JAVA_RUNTIME_VERSION);
    }
    
    /**
     * 获取Java运行时名称
     * @return Java运行时名称，如果获取失败返回null
     */
    public static String getJavaRuntimeName() {
        return get(JavaPropsKey.JAVA_RUNTIME_NAME);
    }
    
    /**
     * 获取Java类版本
     * @return Java类文件版本号，如果获取失败返回null
     */
    public static String getJavaClassVersion() {
        return get(JavaPropsKey.JAVA_CLASS_VERSION);
    }
    
    /**
     * 获取Java规范版本
     * @return Java语言规范版本号，如果获取失败返回null
     */
    public static String getJavaSpecificationVersion() {
        return get(JavaPropsKey.JAVA_SPECIFICATION_VERSION);
    }
    
    /**
     * 获取Java规范名称
     * @return Java语言规范名称，如果获取失败返回null
     */
    public static String getJavaSpecificationName() {
        return get(JavaPropsKey.JAVA_SPECIFICATION_NAME);
    }
    
    /**
     * 获取Java规范供应商
     * @return Java语言规范供应商，如果获取失败返回null
     */
    public static String getJavaSpecificationVendor() {
        return get(JavaPropsKey.JAVA_SPECIFICATION_VENDOR);
    }

    // ==================== JVM相关属性获取方法 ====================
    
    /**
     * 获取JVM名称
     * @return Java虚拟机名称，如果获取失败返回null
     */
    public static String getJavaVmName() {
        return get(JavaPropsKey.JAVA_VM_NAME);
    }
    
    /**
     * 获取JVM版本
     * @return Java虚拟机版本号，如果获取失败返回null
     */
    public static String getJavaVmVersion() {
        return get(JavaPropsKey.JAVA_VM_VERSION);
    }
    
    /**
     * 获取JVM供应商
     * @return Java虚拟机供应商，如果获取失败返回null
     */
    public static String getJavaVmVendor() {
        return get(JavaPropsKey.JAVA_VM_VENDOR);
    }
    
    /**
     * 获取JVM信息
     * @return Java虚拟机详细信息，如果获取失败返回null
     */
    public static String getJavaVmInfo() {
        return get(JavaPropsKey.JAVA_VM_INFO);
    }
    
    /**
     * 获取JVM规范版本
     * @return JVM规范版本号，如果获取失败返回null
     */
    public static String getJavaVmSpecificationVersion() {
        return get(JavaPropsKey.JAVA_VM_SPECIFICATION_VERSION);
    }
    
    /**
     * 获取JVM规范名称
     * @return JVM规范名称，如果获取失败返回null
     */
    public static String getJavaVmSpecificationName() {
        return get(JavaPropsKey.JAVA_VM_SPECIFICATION_NAME);
    }
    
    /**
     * 获取JVM规范供应商
     * @return JVM规范供应商，如果获取失败返回null
     */
    public static String getJavaVmSpecificationVendor() {
        return get(JavaPropsKey.JAVA_VM_SPECIFICATION_VENDOR);
    }

    // ==================== 类路径相关属性获取方法 ====================
    
    /**
     * 获取启动类路径
     * @return JVM启动时使用的类路径，如果获取失败返回null
     */
    public static String getBootClassPath() {
        return get(JavaPropsKey.SUN_BOOT_CLASS_PATH);
    }
    
    /**
     * 获取启动库路径
     * @return JVM启动时使用的库路径，如果获取失败返回null
     */
    public static String getBootLibraryPath() {
        return get(JavaPropsKey.SUN_BOOT_LIBRARY_PATH);
    }
    
    /**
     * 获取类路径
     * @return 当前应用程序的类路径，如果获取失败返回null
     */
    public static String getClassPath() {
        return get(JavaPropsKey.JAVA_CLASS_PATH);
    }
    
    /**
     * 获取扩展目录
     * @return Java扩展目录路径，如果获取失败返回null
     */
    public static String getExtDirs() {
        return get(JavaPropsKey.JAVA_EXT_DIRS);
    }
    
    /**
     * 获取认可目录
     * @return Java认可目录路径，如果获取失败返回null
     */
    public static String getEndorsedDirs() {
        return get(JavaPropsKey.JAVA_ENDORSED_DIRS);
    }
    
    /**
     * 获取库路径
     * @return Java库文件搜索路径，如果获取失败返回null
     */
    public static String getLibraryPath() {
        return get(JavaPropsKey.JAVA_LIBRARY_PATH);
    }

    // ==================== 用户相关属性获取方法 ====================
    
    /**
     * 获取用户名
     * @return 当前用户名称，如果获取失败返回null
     */
    public static String getUserName() {
        return get(JavaPropsKey.USER_NAME);
    }
    
    /**
     * 获取用户主目录
     * @return 当前用户主目录路径，如果获取失败返回null
     */
    public static String getUserHome() {
        return get(JavaPropsKey.USER_HOME);
    }
    
    /**
     * 获取用户工作目录
     * @return 当前用户工作目录路径，如果获取失败返回null
     */
    public static String getUserDir() {
        return get(JavaPropsKey.USER_DIR);
    }
    
    /**
     * 获取用户语言
     * @return 当前用户语言设置，如果获取失败返回null
     */
    public static String getUserLanguage() {
        return get(JavaPropsKey.USER_LANGUAGE);
    }
    
    /**
     * 获取用户国家
     * @return 当前用户国家设置，如果获取失败返回null
     */
    public static String getUserCountry() {
        return get(JavaPropsKey.USER_COUNTRY);
    }
    
    /**
     * 获取用户脚本
     * @return 当前用户脚本设置，如果获取失败返回null
     */
    public static String getUserScript() {
        return get(JavaPropsKey.USER_SCRIPT);
    }
    
    /**
     * 获取用户变体
     * @return 当前用户变体设置，如果获取失败返回null
     */
    public static String getUserVariant() {
        return get(JavaPropsKey.USER_VARIANT);
    }
    
    /**
     * 获取用户时区
     * @return 当前用户时区设置，如果获取失败返回null
     */
    public static String getUserTimezone() {
        return get(JavaPropsKey.USER_TIMEZONE);
    }

    // ==================== 操作系统相关属性获取方法 ====================
    
    /**
     * 获取操作系统名称
     * @return 当前操作系统名称，如果获取失败返回null
     */
    public static String getOsName() {
        return get(JavaPropsKey.OS_NAME);
    }
    
    /**
     * 获取操作系统版本
     * @return 当前操作系统版本号，如果获取失败返回null
     */
    public static String getOsVersion() {
        return get(JavaPropsKey.OS_VERSION);
    }
    
    /**
     * 获取操作系统架构
     * @return 当前操作系统架构，如果获取失败返回null
     */
    public static String getOsArch() {
        return get(JavaPropsKey.OS_ARCH);
    }
    
    /**
     * 获取操作系统补丁级别
     * @return 当前操作系统补丁级别，如果获取失败返回null
     */
    public static String getOsPatchLevel() {
        return get(JavaPropsKey.SUN_OS_PATCH_LEVEL);
    }

    // ==================== Java启动器相关属性获取方法 ====================
    
    /**
     * 获取Java启动器信息
     * @return Java启动器信息，如果获取失败返回null
     */
    public static String getJavaLauncher() {
        return get(JavaPropsKey.SUN_JAVA_LAUNCHER);
    }
    
    /**
     * 获取Java命令
     * @return 启动Java应用程序的命令，如果获取失败返回null
     */
    public static String getJavaCommand() {
        return get(JavaPropsKey.SUN_JAVA_COMMAND);
    }

    // ==================== Java主目录相关属性获取方法 ====================
    
    /**
     * 获取Java主目录
     * @return Java安装目录路径，如果获取失败返回null
     */
    public static String getJavaHome() {
        return get(JavaPropsKey.JAVA_HOME);
    }
    
    /**
     * 获取临时目录
     * @return 系统临时目录路径，如果获取失败返回null
     */
    public static String getJavaIoTmpdir() {
        return get(JavaPropsKey.JAVA_IO_TMPDIR);
    }

    // ==================== AWT相关属性获取方法 ====================
    
    /**
     * 获取AWT工具包
     * @return AWT使用的工具包信息，如果获取失败返回null
     */
    public static String getAwtToolkit() {
        return get(JavaPropsKey.AWT_TOOLKIT);
    }
    
    /**
     * 获取AWT打印机作业
     * @return AWT打印机作业信息，如果获取失败返回null
     */
    public static String getAwtPrinterJob() {
        return get(JavaPropsKey.JAVA_AWT_PRINTERJOB);
    }
    
    /**
     * 获取AWT图形环境
     * @return AWT图形环境信息，如果获取失败返回null
     */
    public static String getAwtGraphicsEnv() {
        return get(JavaPropsKey.JAVA_AWT_GRAPHICSENV);
    }

    // ==================== 编译器相关属性获取方法 ====================
    
    /**
     * 获取编译器管理信息
     * @return 编译器管理信息，如果获取失败返回null
     */
    public static String getManagementCompiler() {
        return get(JavaPropsKey.SUN_MANAGEMENT_COMPILER);
    }

    // ==================== JBoss相关属性获取方法 ====================
    
    /**
     * 获取JBoss模块系统包
     * @return JBoss模块系统包信息，如果获取失败返回null
     */
    public static String getJbossModulesSystemPkgs() {
        return get(JavaPropsKey.JBOSS_MODULES_SYSTEM_PKGS);
    }

    // ==================== 便捷判断方法 ====================
    
    /**
     * 判断是否为Oracle JDK
     * @return 如果是Oracle JDK返回true，否则返回false
     */
    public static boolean isOracleJdk() {
        String vendor = getJavaVendor();
        return vendor != null && vendor.toLowerCase().contains("oracle");
    }
    
    /**
     * 判断是否为OpenJDK
     * @return 如果是OpenJDK返回true，否则返回false
     */
    public static boolean isOpenJdk() {
        String vendor = getJavaVendor();
        return vendor != null && vendor.toLowerCase().contains("openjdk");
    }
    
    /**
     * 判断是否为HotSpot JVM
     * @return 如果是HotSpot JVM返回true，否则返回false
     */
    public static boolean isHotSpotJvm() {
        String vmName = getJavaVmName();
        return vmName != null && vmName.toLowerCase().contains("hotspot");
    }
    
    /**
     * 判断是否为J9 JVM
     * @return 如果是J9 JVM返回true，否则返回false
     */
    public static boolean isJ9Jvm() {
        String vmName = getJavaVmName();
        return vmName != null && vmName.toLowerCase().contains("j9");
    }
    
    /**
     * 判断是否为GraalVM
     * @return 如果是GraalVM返回true，否则返回false
     */
    public static boolean isGraalVm() {
        String vmName = getJavaVmName();
        return vmName != null && vmName.toLowerCase().contains("graal");
    }
    
    /**
     * 获取Java版本的主版本号
     * @return Java主版本号，如果获取失败返回-1
     */
    public static int getJavaMajorVersion() {
        String version = getJavaVersion();
        if (version != null && version.startsWith("1.")) {
            try {
                return Integer.parseInt(version.substring(2, version.indexOf('.', 2)));
            } catch (Exception e) {
                return -1;
            }
        } else if (version != null) {
            try {
                return Integer.parseInt(version.substring(0, version.indexOf('.')));
            } catch (Exception e) {
                return -1;
            }
        }
        return -1;
    }
    
    /**
     * 判断是否为Java 8或更高版本
     * @return 如果是Java 8或更高版本返回true，否则返回false
     */
    public static boolean isJava8OrHigher() {
        int majorVersion = getJavaMajorVersion();
        return majorVersion >= 8;
    }
    
    /**
     * 判断是否为Java 11或更高版本
     * @return 如果是Java 11或更高版本返回true，否则返回false
     */
    public static boolean isJava11OrHigher() {
        int majorVersion = getJavaMajorVersion();
        return majorVersion >= 11;
    }
    
    /**
     * 判断是否为Java 17或更高版本
     * @return 如果是Java 17或更高版本返回true，否则返回false
     */
    public static boolean isJava17OrHigher() {
        int majorVersion = getJavaMajorVersion();
        return majorVersion >= 17;
    }

}